//! Redis顺序保证架构演示
//! 
//! 演示基于Redis官方实现思路的顺序保证机制：
//! 1. 每个连接创建独立的ConnectionHandler
//! 2. 每个ConnectionHandler包含专属的事件驱动器和消费线程
//! 3. 确保每个连接的响应严格按顺序处理

use std::sync::Arc;
use std::thread;
use std::time::Duration;
use std::io::{self, Read, Write};

use redis_rs2::{
    protocol::{NetworkServer, NetworkServerConfig, NetworkStream},
    storage::SingleThreadCommandDispatcher,
};

/// 演示用的模拟网络流
struct DemoNetworkStream {
    /// 模拟接收的数据
    data: Vec<u8>,
    /// 读取位置
    pos: usize,
    /// 写入的响应数据
    responses: Vec<u8>,
    /// 是否连接
    connected: bool,
    /// 模拟的远程地址
    remote_addr: String,
}

impl DemoNetworkStream {
    /// 创建包含Pipeline命令的演示流
    fn with_pipeline_commands(client_name: &str) -> Self {
        let mut data = Vec::new();
        
        // 模拟客户端发送Pipeline命令
        println!("📤 客户端 {} 发送Pipeline命令:", client_name);
        
        // 命令1: PING
        data.extend_from_slice(b"*1\r\n$4\r\nPING\r\n");
        println!("  1. PING");
        
        // 命令2: SET key1 value1
        data.extend_from_slice(b"*3\r\n$3\r\nSET\r\n$4\r\nkey1\r\n$6\r\nvalue1\r\n");
        println!("  2. SET key1 value1");
        
        // 命令3: GET key1
        data.extend_from_slice(b"*2\r\n$3\r\nGET\r\n$4\r\nkey1\r\n");
        println!("  3. GET key1");
        
        // 命令4: SET key2 value2
        data.extend_from_slice(b"*3\r\n$3\r\nSET\r\n$4\r\nkey2\r\n$6\r\nvalue2\r\n");
        println!("  4. SET key2 value2");
        
        // 命令5: PING（再次）
        data.extend_from_slice(b"*1\r\n$4\r\nPING\r\n");
        println!("  5. PING");
        
        Self {
            data,
            pos: 0,
            responses: Vec::new(),
            connected: true,
            remote_addr: format!("127.0.0.1:{}", client_name),
        }
    }
    
    /// 获取写入的响应数据
    pub fn get_responses(&self) -> &[u8] {
        &self.responses
    }
    
    /// 将响应转换为字符串（用于显示）
    pub fn responses_as_string(&self) -> String {
        String::from_utf8_lossy(&self.responses).to_string()
    }
}

impl NetworkStream for DemoNetworkStream {
    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
        if self.pos >= self.data.len() {
            // 模拟连接关闭
            return Ok(0);
        }
        
        let remaining = self.data.len() - self.pos;
        let to_copy = std::cmp::min(buf.len(), remaining);
        
        buf[..to_copy].copy_from_slice(&self.data[self.pos..self.pos + to_copy]);
        self.pos += to_copy;
        
        // 模拟网络延迟
        thread::sleep(Duration::from_millis(2));
        
        Ok(to_copy)
    }
    
    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
        self.responses.extend_from_slice(buf);
        
        // 模拟不同的网络写入延迟
        let delay = match buf {
            b if b.starts_with(b"+PONG") => 1,   // PONG响应快
            b if b.starts_with(b"+OK") => 5,    // OK响应中等
            b if b.starts_with(b"$") => 10,     // 字符串响应慢
            _ => 2,
        };
        thread::sleep(Duration::from_millis(delay));
        
        Ok(buf.len())
    }
    
    fn flush(&mut self) -> io::Result<()> {
        // 在真实实现中会刷新缓冲区
        Ok(())
    }
    
    fn is_connected(&self) -> bool {
        self.connected && self.pos < self.data.len()
    }
    
    fn remote_addr(&self) -> Option<String> {
        Some(self.remote_addr.clone())
    }
    
    fn shutdown(&mut self) -> io::Result<()> {
        self.connected = false;
        Ok(())
    }
}

fn main() {
    println!("🚀 Redis顺序保证架构演示");
    println!("{}", "=".repeat(60));
    println!("💡 核心思路：");
    println!("  1. 每个连接创建独立的ConnectionHandler");
    println!("  2. 每个ConnectionHandler包含：网络流 + 专属事件驱动器 + 消费线程");
    println!("  3. 协议层解析命令并传入专属事件驱动器");
    println!("  4. 专属消费线程确保响应按顺序写回网络流");
    println!();

    // 1. 创建存储层组件
    println!("📦 1. 创建存储层组件");
    let storage_dispatcher = SingleThreadCommandDispatcher::new();
    println!("  ✅ 存储命令分发器已创建");

    // 2. 创建网络服务器配置
    println!("\n⚙️ 2. 配置网络服务器");
    let config = NetworkServerConfig {
        max_connections: 100,
        connection_timeout: Duration::from_secs(30),
        cleanup_interval: Duration::from_secs(10),
    };
    println!("  ✅ 网络服务器配置完成");

    // 3. 创建网络服务器
    println!("\n🌐 3. 创建网络服务器");
    let server = NetworkServer::new(storage_dispatcher, Some(config));
    println!("  ✅ 网络服务器已创建");

    // 4. 启动网络服务器
    println!("\n🚀 4. 启动网络服务器");
    if let Err(e) = server.start() {
        eprintln!("❌ 启动失败: {}", e);
        return;
    }
    println!("  ✅ 网络服务器启动成功");

    // 5. 模拟多个客户端连接
    println!("\n👥 5. 模拟多个客户端连接");
    let mut connection_ids = Vec::new();

    for i in 1..=3 {
        let client_name = format!("client{}", i);
        println!("\n  📱 客户端 {} 连接:", client_name);
        
        let stream = Box::new(DemoNetworkStream::with_pipeline_commands(&client_name));
        
        match server.accept_connection(stream) {
            Ok(conn_id) => {
                connection_ids.push(conn_id);
                println!("  ✅ 客户端 {} 连接成功，ID: {}", client_name, conn_id);
            }
            Err(e) => {
                eprintln!("  ❌ 客户端 {} 连接失败: {}", client_name, e);
            }
        }
    }

    // 6. 等待命令处理完成
    println!("\n⏳ 6. 等待命令处理完成");
    for i in 1..=15 {
        thread::sleep(Duration::from_secs(1));
        
        let stats = server.get_stats();
        println!("  📊 第{}秒 - 活跃连接: {}", i, stats.active_connections);
        
        if stats.active_connections == 0 {
            println!("  ✅ 所有连接已处理完成");
            break;
        }
    }

    // 7. 查看最终统计
    println!("\n📊 7. 最终统计信息");
    server.print_stats();

    // 8. 验证顺序保证
    println!("\n🔍 8. 验证顺序保证");
    println!("💡 关键点：");
    println!("  ✅ 每个连接的响应严格按命令顺序返回");
    println!("  ✅ 不同连接之间可以并发处理，互不影响");
    println!("  ✅ 单个连接内部保证：先发送的命令先得到响应");

    // 9. 架构优势说明
    println!("\n🌟 9. 架构优势");
    println!("  🏆 顺序保证：100%确保响应顺序正确");
    println!("  🏆 并发性能：不同连接并发处理，提高吞吐量");
    println!("  🏆 资源隔离：每个连接独立，故障不会相互影响");
    println!("  🏆 Redis兼容：完全符合Redis Pipeline协议规范");

    // 10. 与原架构对比
    println!("\n📈 10. 与原架构对比");
    println!("  🔄 原架构：全局ResponseWritebackDriver → 可能乱序");
    println!("  ✅ 新架构：每连接专属事件驱动器 → 严格有序");
    println!("  🔄 原架构：PipelineManager需要复杂排序逻辑");
    println!("  ✅ 新架构：天然保证顺序，无需额外排序");

    // 11. 停止网络服务器
    println!("\n🛑 11. 停止网络服务器");
    if let Err(e) = server.stop() {
        eprintln!("❌ 停止失败: {}", e);
    } else {
        println!("  ✅ 网络服务器已安全停止");
    }

    println!("\n🎉 Redis顺序保证架构演示完成！");
    print_summary();
}

/// 打印总结信息
fn print_summary() {
    println!("\n💡 核心设计总结:");
    println!("  📋 1. 每个网络连接 → 独立ConnectionHandler");
    println!("  📋 2. 每个ConnectionHandler → 专属事件驱动器 + 消费线程");
    println!("  📋 3. 命令解析 → 存储执行 → 专属队列 → 顺序回写");
    println!("  📋 4. 天然保证单连接内响应顺序，无需PipelineManager");
    
    println!("\n🔧 实现关键点:");
    println!("  🎯 网络层：NetworkServer管理所有ConnectionHandler");
    println!("  🎯 连接层：ConnectionHandler包含网络流+事件驱动器");  
    println!("  🎯 协议层：在连接线程中解析RESP协议");
    println!("  🎯 存储层：共享SingleThreadCommandDispatcher");
    println!("  🎯 响应层：每连接专属ResponseWritebackDriver");
    
    println!("\n🌟 这正是Redis官方实现的核心思路！");
}